interface Iperson {
    sing: (s: number) => number;
    name: string;
    age: number;
}


interface Ianimal {
    run: () => void;
}

class P implements Ianimal, Iperson {
    sing: (se: number) => number;
    name: string;
    age: number;
    run: () => void;

    constructor(
        name: string,
        age: number,
        sing: (se: number) => number,
        run: () => void
    ) {
        this.name = name;
        this.age = age;
        this.sing = sing;
        this.run = run;
    }
}

function pppp(se: number) {
    return se;
}

const p = new P("", 25, pppp, () => {
    console.log(222);
});
console.log(p.sing(65));

// 人和动物同时继承奔跑的动作
class an implements Ianimal {
    sing: () => string;
    name: string;
    age: number;
    run: () => void;
}

type Ifruits = {
    apple: (...agrs: any) => void;
};

class FruitSDA implements Ifruits {
    apple: () => {};
}


// interface 只是指定检查条件，如果不满足这些条件就会报错。它并不能代替 class 自身的类型声明。
// 类B实现了接口A，但是后者并不能代替B的类型声明。
// 因此，B的get()方法的参数s的类型是any，而不是string。B类依然需要声明参数s的类型。

// 总结就是接口在类中只能实现类的结果不能实现类成员的类型
interface A {
    name: string

    check(name: string): boolean

    get(name: string): boolean;
}


class Be implements A {
    name: string;

    check(name): boolean {
        return name.length > 0
    }

    get(s) {
        return s.length > 0;
    }
}


const zez: A = new Be()

// TypeScript 不允许两个同名的类，但是如果一个类和一个接口同名，那么接口会被合并进类。